home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Unix / mcvert2.15.shar / hqxify.c next >
Encoding:
C/C++ Source or Header  |  1993-11-25  |  27.6 KB  |  1,012 lines
  1. #include "mactypes.h"
  2.  
  3. /* HQXBUFLEN must be large enough to hold a complete hqx header */
  4. #define HQXBUFLEN 512
  5. byte hqxbuf[HQXBUFLEN + 1], *buf_ptr, *buf_end, *buf_start = hqxbuf + 1;
  6.  
  7. /* Note: line[0] stores the run length character,
  8.  * so line is one greater than MAXLINE  */
  9. #define MAXLINE 2048
  10. byte line[MAXLINE + 1], *line_ptr, *line_end, *line_start = line + 1;
  11.  
  12. /* keep the compiler happy */
  13. #define LINE_START ((char*)(line_start))
  14.  
  15. extern char *cmdname;
  16.  
  17. int line_count, file_count;
  18. int save_state, total_bytes, save_run_length;
  19. word save_accum;
  20. char binfname[SYSNAMELEN], hqxfname[SYSNAMELEN];
  21. FILE *hqxfile, *binfile;
  22.  
  23.  
  24. /*
  25.  * hqxsuspect caches whether or not we have gotten past all suspect data
  26.  * at the head of a file, for example, a mail header.  hqxsuspect is set
  27.  * on every new hqx file read, and reset only in non_suspect()
  28.  */
  29. int hqxsuspect;
  30. extern suspect_shorter;
  31. extern suspect_same;
  32.  
  33. extern int info_only;
  34.  
  35. /* This routine reads the header of a hqxed file and appropriately twiddles it,
  36.     determines if it has CRC problems, creates the .bin file, and puts the info
  37.     into the .bin file.
  38.     Output is hqx_datalen, hqx_rsrclen, type, binfname, binfile.
  39.      Returns 0 iff failed to read header.
  40.  */
  41.  
  42.  
  43. int
  44. hqx_to_bin_hdr(type, hqx_datalen, hqx_rsrclen, same_file_only)
  45.     char *type;
  46.     ulong *hqx_datalen, *hqx_rsrclen;
  47.     int same_file_only;
  48. {
  49.     register byte *hqx_ptr, *hqx_end;
  50.     register ulong calc_crc;
  51.     hqx_buf *hqx_block;
  52.     hqx_header *hqx;
  53.     info_header info;
  54.     ulong mtim;
  55.     short crc;
  56.     long len;
  57.  
  58.     extern word magic[];
  59.     extern char *dir, *ext;
  60.     extern short calc_mb_crc();
  61.  
  62.     /* read the hqx header, 
  63.      * assuming that I won't exhaust hqxbuf in so doing --
  64.      * that is, that hqxbuf is always large enough (it is)
  65.      */
  66.     (void)fill_hqxbuf(same_file_only);
  67.     /*
  68.      * If we are reading multiple files, then we could have the last
  69.      * unread line of the "previous" file be just a colon (since we are
  70.      * length driven, and stopped when we processed the expected
  71.      * lengths), and the prior fill_hqxbuf() call would find it and
  72.      * return 0, leaving the buffer unfilled.  So, if we have zero
  73.      * bytes so far, just fill it again.
  74.      */
  75.     if (total_bytes == 0) {
  76.         DEBUG && fprintf(debug,
  77.             "%s: Note: had to call fill_hqxbuf again in hqx_to_bin_hdr\n",
  78.             cmdname);
  79.         DEBUG && fflush(debug);
  80.         (void)fill_hqxbuf(same_file_only);
  81.     }
  82.     if (same_file_only == 1 && total_bytes == 0)
  83.         return 0;
  84.     if (total_bytes < MIN_HQX_HDR) {
  85.         fprintf(verbose, "%s: %s (%d < %d): bad file format? -- exiting\n",
  86.             cmdname, "error: hqx_header too short", total_bytes, MIN_HQX_HDR);
  87.         fflush(verbose);
  88.         exit(2);
  89.     }
  90.  
  91.     hqx_block = (hqx_buf *) buf_ptr;
  92.     hqx = (hqx_header *) (hqx_block->name + hqx_block->nlen);
  93.     hqx_ptr = buf_ptr;
  94.     hqx_end = (byte *) hqx + sizeof(hqx_header) - 1;
  95.     calc_crc = 0;
  96.     while (hqx_ptr < hqx_end)
  97.         calc_crc = (((calc_crc & 0xff) << 8) | *hqx_ptr++) ^ magic[calc_crc >> 8];
  98.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  99.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  100.     buf_ptr = hqx_ptr;
  101.  
  102.     /* stuff the hqx header data into the info header */
  103.     bzero((char*)&info, sizeof(info_header));
  104.     info.nlen = hqx_block->nlen;
  105.     if (info.nlen > sizeof(info.name))
  106.         error("Error: corrupt BinHex data format", "");
  107.     strncpy((char*)info.name, (char*)hqx_block->name, (int)info.nlen);/* name */
  108.  
  109.     /* now make sure the resulting name is valid for length only */
  110.     info.nlen = macify((char*)info.name, (int)info.nlen, 0);
  111.  
  112.     bcopy((char*)hqx->type, (char*)info.type, 9);       /* type, author, flag */
  113.     info.flags &= 0x7e;               /* reset lock bit, init bit */
  114.     if (hqx->protect & 0x40)
  115.         info.protect = 1;           /* copy protect bit */
  116.     bcopy((char*)hqx->dlen, (char*)info.dlen, 8);           /* dlen, rlen */
  117.     mtim = unix2mac((ulong)time((long*)0));
  118.     bcopy((char*)&mtim, (char*)info.mtim, 4);
  119.     bcopy((char*)&mtim, (char*)info.ctim, 4);
  120.     info.uploadvers = '\201';
  121.     info.readvers = '\201';
  122.  
  123.     /* calculate MacBinary CRC */
  124.     crc = calc_mb_crc((unsigned char*)&info, 124L, 0);
  125.     info.crc[0] = (char) (crc >> 8);
  126.     info.crc[1] = (char) crc;
  127.  
  128.     /* Create the .bin file and write the info to it */
  129.  
  130.     unixify((char*)hqx_block->name);
  131.     converting(info.name, (int)info.nlen, info.type, info.auth);
  132.     print_bin_hdr("Creating", &info);
  133.  
  134.     len = strlen(dir) + strlen((char*)hqx_block->name) + strlen(ext) + 1;
  135.     if (len >= sizeof(binfname))
  136.         error("Error: generated binfname would be too long", "");
  137.     sprintf(binfname, "%s/%s%s", dir, hqx_block->name, ext);
  138.     binfile = mopen(binfname, "", "w");
  139.  
  140.     check_hqx_crc((word)calc_crc, "File header CRC mismatch in %s", binfname);
  141.     if (1 != fwrite((char*)&info, sizeof(info), 1, binfile))
  142.         error("fwrite failed on binfile", "");
  143.  
  144.     /* Get a couple of items we'll need later */
  145.     bcopy((char*)info.dlen, (char*)hqx_datalen, 4);
  146.     *hqx_datalen = mac2long(*hqx_datalen);
  147.     bcopy((char*)info.rlen, (char*)hqx_rsrclen, 4);
  148.     *hqx_rsrclen = mac2long(*hqx_rsrclen);
  149.     bcopy((char*)info.type, (char*)type, 4);
  150.  
  151.     /* emit useful debugging info */
  152.     DEBUG && fprintf(debug, "\tdata_len=%10ld\t\trsrc_len=%10ld\n",
  153.         *hqx_datalen, *hqx_rsrclen);
  154.     DEBUG && fflush(debug);
  155.  
  156.     return 1;
  157. }
  158.  
  159. /* This routine reads the header of a bin file and appropriately twiddles it,
  160.     creates the .hqx file, and puts the info into the .hqx file.
  161.     Output is hqx_datalen, hqx_rsrclen, type, hqxfname, hqxfile */
  162.  
  163. bin_to_hqx_hdr(hqx_datalen, hqx_rsrclen)
  164.     ulong *hqx_datalen, *hqx_rsrclen;
  165. {
  166.     register byte *hqx_ptr, *hqx_end;
  167.     register ulong calc_crc;
  168.     hqx_buf *hqx_block;
  169.     hqx_header *hqx;
  170.     info_header info;
  171.     extern word magic[];
  172.     extern char **hqxnames_left;
  173.     extern char *ext;
  174.     long len;
  175.  
  176.     len = strlen(*hqxnames_left);
  177.     if (len >= sizeof(binfname))
  178.         error("Error: specified binfname is too long", "");
  179.     strcpy(binfname, *hqxnames_left++);
  180.     binfile = mopen(binfname, ext, "r");
  181.  
  182.     if (!fread((char*)&info, sizeof(info), 1, binfile))
  183.         error("Unexpected EOF in MacBinary header of %s", binfname);
  184.  
  185.     /* stuff the info header into the hqx header */
  186.     hqx_block = (hqx_buf *) buf_ptr;
  187.     hqx_block->nlen = info.nlen;
  188.     if (info.nlen > sizeof(hqx_block->name))
  189.         error("Error: corrupt MacBinary data format", "");
  190.     strncpy((char*)hqx_block->name, (char*)info.name, (int)info.nlen);
  191.     /*
  192.      * We expect a valid Macintosh file name since it came from a MacBinary file
  193.      * so we don't potentially corrupt a valid copied name via macify translate.
  194.      * File name length should not be a problem, so we do nothing.
  195.      */
  196.     hqx = (hqx_header *) (hqx_block->name + hqx_block->nlen);
  197.     hqx->version = 0;
  198.     bcopy((char*)info.type, (char*)hqx->type, 9);   /* type, author, flags */
  199.     hqx->flags &= 0x7e;               /* reset lock bit, init bit */
  200.     if (info.protect == 1)
  201.         hqx->protect = 0;           /* protect bit: 0x40 */
  202.     else
  203.         hqx->protect = 0;
  204.     bcopy((char*)info.dlen, (char*)hqx->dlen, 8);           /* dlen, rlen */
  205.  
  206.     /* Create the .hqx file and write the info to it */
  207.  
  208. #ifdef notdef
  209.        This is the right thing to check but the Sun optimizing
  210.        compiler gives a (valid) warning that info.nlen (one char,
  211.        255 max) is always less than sizeofhqxfname) which is
  212.        hardwired to 1024 since version 1.99.  Since we have already
  213.        checked info.nlen above, we skip the test and avoid the warning.
  214.  
  215.     if (info.nlen >= sizeof(hqxfname))
  216.         error("Error: generated hqxfname would be too long", "");
  217. #endif
  218.  
  219.     strncpy(hqxfname, (char*)info.name, (int)info.nlen);
  220.     hqxfname[info.nlen] = '\0';
  221.     unixify(hqxfname);
  222.     converting(info.name, (int)info.nlen, info.type, info.auth);
  223.     print_bin_hdr("Reading", &info);
  224.  
  225.     calc_crc = 0;
  226.     hqx_ptr = (byte *) hqx_block;
  227.     hqx_end = hqx_ptr + hqx_block->nlen + sizeof(hqx_header);
  228.     while (hqx_ptr < hqx_end)
  229.         calc_crc = (((calc_crc & 0xff) << 8) | *hqx_ptr++) ^ magic[calc_crc >> 8];
  230.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  231.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  232.     buf_ptr = hqx_end;
  233.     write_hqx_crc((word)calc_crc);
  234.  
  235.     /* Get a couple of items we'll need later */
  236.     bcopy((char*)info.dlen, (char*)hqx_datalen, 4);
  237.     *hqx_datalen = mac2long(*hqx_datalen);
  238.     bcopy((char*)info.rlen, (char*)hqx_rsrclen, 4);
  239.     *hqx_rsrclen = mac2long(*hqx_rsrclen);
  240. }
  241.  
  242.  
  243. /* This routine copies bytes from the decoded input stream to the output.  
  244.     It also pads to a multiple of 128 bytes on the output, which is part
  245.     of the .bin format */
  246. word
  247. hqx_to_bin_fork(nbytes)
  248.     register ulong nbytes;
  249. {
  250.     register byte *cp;
  251.     register ulong calc_crc;
  252.     register int c_length;
  253.     ulong extra_bytes;
  254.     extern word magic[];
  255.     long avail = 0;    /* used for internal consistency checking */
  256.     int wrote;
  257.  
  258.     extra_bytes = 127 - (nbytes + 127) % 128;    /* pad fork to mult of
  259.                              * 128 bytes */
  260.     calc_crc = 0;
  261.     for (;;) {
  262.         cp = buf_ptr;
  263.         c_length = (cp + nbytes > buf_end) ? buf_end - cp : nbytes;
  264.         /* we can only check readily if we read it here */
  265.         if (avail && c_length > avail)
  266.             error("hqx_to_bin_fork: writing %ld too many bytes",
  267.                 (char*)c_length - avail);
  268.         nbytes -= c_length;
  269.         wrote = fwrite((char*)cp, sizeof(byte), c_length, binfile);
  270.         if (wrote != c_length)
  271.             error("hqx_to_bin_fork: fwrite on binfile wrote %ld bytes too few",
  272.                 (char*)c_length-wrote);
  273.         while (c_length--)
  274.             calc_crc = (((calc_crc & 0xff) << 8) | *cp++) ^ magic[calc_crc >> 8];
  275.         if (!nbytes)
  276.             break;
  277.         avail = fill_hqxbuf(0);
  278.     }
  279.     buf_ptr = cp;
  280.     while (extra_bytes--)
  281.         if (EOF == putc(0, binfile))
  282.             error("Error: putc failed on binfile", "");
  283.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  284.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  285.     return (word) calc_crc;
  286. }
  287.  
  288. /* This routine copies bytes from the input stream to the encoded output.  
  289.     It also pads to a multiple of 128 bytes on the input, which is part
  290.     of the .bin format */
  291. word
  292. bin_to_hqx_fork(nbytes)
  293.     register ulong nbytes;
  294. {
  295.     register byte *cp;
  296.     register ulong calc_crc;
  297.     register int c_length;
  298.     ulong extra_bytes;
  299.     extern word magic[];
  300.  
  301.     extra_bytes = 127 - (nbytes + 127) % 128;    /* pad fork to mult of
  302.                              * 128 bytes */
  303.     calc_crc = 0;
  304.     for (;;) {
  305.         cp = buf_ptr;
  306.         c_length = (cp + nbytes > buf_end) ? buf_end - cp : nbytes;
  307.         nbytes -= c_length;
  308.         if (c_length != fread((char*)cp, sizeof(byte), c_length, binfile))
  309.             error("fread failed on binfile", "");
  310.         buf_ptr += c_length;
  311.         while (c_length--)
  312.             calc_crc = (((calc_crc & 0xff) << 8) | *cp++) ^ magic[calc_crc >> 8];
  313.         if (!nbytes)
  314.             break;
  315.         empty_hqxbuf();
  316.     }
  317.     buf_ptr = cp;
  318.  
  319.     fseek(binfile, (long)extra_bytes, 1);
  320.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  321.     calc_crc = ((calc_crc & 0xff) << 8) ^ magic[calc_crc >> 8];
  322.     return (word) calc_crc;
  323. }
  324.  
  325. /* Essentials for Binhex 8to6 run length encoding */
  326. #define RUNCHAR 0x90
  327. #define MAXRUN 255
  328. #define IS_LEGAL <0x40
  329. #define ISNT_LEGAL >0x3f
  330. #define DONE 0x7F        /* tr68[':'] = DONE, since Binhex terminator is ':' */
  331. #define SKIP 0x7E        /* tr68['\n'|'\r'] = SKIP, i. e. end of line char.  */
  332.     /* We also treat '\0' as SKIP to handle files without trailing newline */
  333.  
  334.     /*
  335.        NOTE: we really don't do a very good job of handling lines
  336.        with ^M's as the end of line character, since we jettison
  337.        the entire UNIX line (which can look like multiple Mac
  338.        lines) when rejecting the line.  Easiest way to fix this is
  339.        to write our own version of fgets which breaks on ^M or ^J.
  340.      */
  341.  
  342. #define FAIL 0x7D        /* character illegal in binhex file */
  343.  
  344. byte tr86[] =
  345. "!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr";
  346. byte tr68[] = {
  347. /* 0x00 */
  348.     SKIP, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  349.     FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
  350. /* 0x10 */
  351.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  352.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  353. /* 0x20 */
  354.     FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  355.     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
  356. /* 0x30 */
  357.     0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
  358.     0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
  359. /* 0x40 */
  360.     0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
  361.     0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
  362. /* 0x50 */
  363.     0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
  364.     0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
  365. /* 0x60 */
  366.     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
  367.     0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
  368. /* 0x70 */
  369.     0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
  370.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  371. /* 0x80 */
  372.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  373.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  374. /* 0x90 */
  375.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  376.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  377. /* 0xA0 */
  378.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  379.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  380. /* 0xB0 */
  381.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  382.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  383. /* 0xC0 */
  384.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  385.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  386. /* 0xD0 */
  387.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  388.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  389. /* 0xE0 */
  390.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  391.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  392. /* 0xF0 */
  393.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  394.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  395. };
  396.  
  397. /*
  398.  *  This procedure transparently reads and decodes the hqx input.
  399.  *  It does run length and 6 to 8 decoding.
  400.  *  As many lines as required are read to fill up buf.
  401.  * Global Input
  402.  *  buf_start
  403.  *  line_ptr
  404.  *  save_*
  405.  * Global Output
  406.  *  buf_ptr end of buffer used
  407.  *  line_ptr
  408.  *  save_*
  409.  * Internal
  410.  *  line     holds the encoded incoming ascii line.
  411.  *  buf      holds the decoding binary binary. [what the heck does this mean?]
  412.  *  buf[-1]  holds the character to be repeated for run length encoding.
  413.  */
  414. #define READING 0
  415. #define SKIPPING 1
  416. #define FIND_START_COLON 2
  417. #define FINDING_COLON 3
  418.  
  419. /*
  420.  
  421.  * It's too bad we can't look for ``(This file ..'' when hunting for a
  422.  * starting colon, but we don't emit such a line at the head of every
  423.  * segment, so we can't expect to find one, now, can we?
  424.  
  425.  * We were really too brittle when scanning, since we only
  426.  * accepted lines which were exactly 64 (HQXLINELEN) characters long.
  427.  * Fixed in version 1.83.  But allowing any length valid line
  428.  * permitted the false-match-in-mail-headers-problem for lines like "---".
  429.  * Better header skipping provided in 1.84.
  430.  
  431.  * XXX: rather than decode line inplace, it would be better
  432.  * to leave the original intact to enable better warning messages
  433.  
  434.  */
  435.  
  436. /* returns the number of bytes read */
  437. fill_hqxbuf(same_file_only)
  438.     int same_file_only;
  439. {
  440.     register ulong c, accum;
  441.     register int not_in_a_run = TRUE, state68;
  442.     register byte *fast_buf, *fast_line;
  443.     static int phase = FIND_START_COLON;
  444.     long avail;
  445.  
  446.     buf_ptr = fast_buf = buf_start;
  447.     fast_line = line_ptr;
  448.     state68 = save_state;
  449.     accum = save_accum;
  450.     if (save_run_length > 0) {
  451.         c = save_run_length;
  452.         save_run_length = 0;
  453.         goto continue_run;
  454.     }
  455.  
  456.     while (fast_buf < buf_end) {
  457.  
  458. next_char:
  459.         if ((c = *fast_line++) ISNT_LEGAL) {
  460.             if (c == DONE) {
  461.                 /* done processing the file, so get out */
  462.                 /* phase has already been set by read processing */
  463.                 break;
  464.           }
  465.  
  466.     next_line:
  467.             if (!fgets(LINE_START, MAXLINE, hqxfile)) {
  468.                 if (same_file_only) {
  469.                     avail = fast_buf - buf_ptr;
  470.                     if (avail != 0) {
  471.                         DEBUG && fprintf(debug, "DEBUG: avail: %d\n", avail);
  472.                         DEBUG && fflush(debug);
  473.                         error(
  474.                 "Premature EOF reading non-initial BinHex 4.0 header from %s",
  475.                             hqxfname);
  476.                     } else {
  477.                         /* this routine may be called many times in a row,
  478.                          * and we must ensure that we don't allow fast_line
  479.                          * to march beyond the end of line (it did), so we jam
  480.                          * fast_line to the start of the line, and salt the
  481.                          * line to mark it invalid, so a new line will be fetched.
  482.                          * Jeepers, how I hate the (il)logic of this routine!
  483.                          */
  484.                         fast_line = line_start;
  485.                         *fast_line = SKIP;
  486.                         break;
  487.                     }
  488.                     /*NOTREACHED*/
  489.                 } else if (new_in_hqx_file() == 0) {
  490.                     /*
  491.                      * Used to assume if no more input available through error or
  492.                      * exhaustion while looking for valid data then must be done.
  493.                      * But we are demand driven (now) and if called, must
  494.                      * find data.  So we don't silently exit any more.
  495.                      */
  496.                     error("Premature EOF while reading BinHex 4.0 %s", hqxfname);
  497.                 }
  498.             }
  499.             line_ptr = line_start;
  500.  
  501.             if (Debug > 1) {
  502.                       fprintf(debug, "DEBUG: input: %s", line_start);
  503.                       fflush(debug);
  504.              }
  505.  
  506.     scan_line:
  507.  
  508.             /* ensure the the entire line is valid */
  509.  
  510.             fast_line = line_ptr;
  511.             while ((*fast_line = tr68[*fast_line]) IS_LEGAL)
  512.                 fast_line++;
  513.  
  514.             /* grab the stopper */
  515.             c = *fast_line;
  516.  
  517.             /* check for validity, transition phases as required */
  518.             switch (phase) {
  519.  
  520.             case READING:
  521.             case SKIPPING:
  522.             case FINDING_COLON:
  523.                 if (SKIP == c && fast_line > line_ptr &&
  524.                     ( 0 == hqxsuspect ||
  525.                         non_suspect((char *)line_ptr, (char *)fast_line) )
  526.                 ) {
  527.                     /* the entire line is valid (again), so (resume) reading */
  528.                     /* hack: require the line to be non-empty to simplify logic */
  529.                     /* require line to non suspect [outside [mail] header] */
  530.                     phase = READING;
  531.                     break;
  532.                 }
  533.                 if (c == DONE && tr68[fast_line[1]] == SKIP) {
  534.                     /*
  535.                      * valid encoded last line, so
  536.                      * set phase for next line, and process this line --
  537.                      * we exit the fill-the-buffer loop when the terminal
  538.                      * colon is encountered during line processing
  539.                      */
  540.                     phase = FIND_START_COLON;
  541.                     break;
  542.                 }
  543.  
  544.                 /* line is not entirely valid, so do some flavor of skipping */
  545.                 phase = (phase == FINDING_COLON) ? FIND_START_COLON : SKIPPING;
  546.                 /* we're suspicious again, since we could be reading a
  547.                  * concatenated multi-segmented file */
  548.                 hqxsuspect = 1;
  549.                 goto next_line;
  550.  
  551.             case FIND_START_COLON:
  552.                 if (*line_start == DONE) {
  553.                     /* can't transition to READING
  554.                      * until know that entire line is valid
  555.                      * so transition to intermediate state
  556.                      */
  557.                     phase = FINDING_COLON;
  558.                     /* skip the initial colon */
  559.                     line_ptr++;
  560.                     goto scan_line;
  561.                 }
  562.                 goto next_line;
  563.  
  564.             }
  565.  
  566.             /* we've read in a valid line, so start processing it */
  567.             fast_line = line_ptr;
  568.             c = *fast_line++;
  569.  
  570.             /*
  571.              * Jskud 15Jul92: fix bug reported by Info-Mac Moderator Bill
  572.              * regarding case of last line just :
  573.              * The line is valid, but it has no data, so don't ingest it.
  574.              */
  575.  
  576.             if (c == DONE)
  577.                 break;
  578.  
  579.             if (Debug > 1) {
  580.                 fprintf(debug, "DEBUG: processing above line\n\n");
  581.                 fflush(debug);
  582.             }
  583.  
  584.         }
  585.  
  586.         /* Finally, we have the next 6 bits worth of data in "c" as input. */
  587.         /* Note: we use "c" as the output of this processing too */
  588.         switch (state68++) {
  589.         case 0:
  590.             accum = c;
  591.             goto next_char;
  592.         case 1:
  593.             accum = (accum << 6) | c;
  594.             c = accum >> 4;
  595.             break;
  596.         case 2:
  597.             accum = (accum << 6) | c;
  598.             c = (accum >> 2) & 0xff;
  599.             break;
  600.         case 3:
  601.             /* we avoid any miniscule optimizations here
  602.              * to maintain parallelism and clarity
  603.              * which should enhance program maintainability
  604.              */
  605.             accum = (accum << 6) | c;
  606.             c = accum & 0xff;
  607.             state68 = 0;
  608.             break;
  609.         }
  610.         if (not_in_a_run)
  611.             if (c != RUNCHAR)
  612.                 *fast_buf++ = c;
  613.             else {
  614.                 not_in_a_run = FALSE;
  615.                 goto next_char;
  616.             }
  617.         else {
  618.             /* "c" has the run total length, not just the incremental,
  619.                hence the post decrement is correct */
  620.             if (c--) {
  621.                 avail = buf_end - fast_buf;
  622.                 if (c > avail) {
  623.                     save_run_length = c - avail;
  624.                     c = avail;
  625.                 }
  626.         continue_run:
  627.                 {
  628.                     register char ch = fast_buf[-1];
  629.  
  630.                     while (c--)
  631.                         *fast_buf++ = ch;
  632.                 }
  633.  
  634.             } else
  635.                 /* handle special case of 0x9000 => 0x90 */
  636.                 *fast_buf++ = RUNCHAR;
  637.  
  638.             not_in_a_run = TRUE;
  639.         }
  640.     }
  641.  
  642. /* exit: */
  643.     avail = fast_buf - buf_ptr;
  644.     total_bytes += avail;
  645.     buf_start[-1] = fast_buf[-1];
  646.     line_ptr = fast_line;
  647.     save_state = state68;
  648.     save_accum = accum;
  649.  
  650.     return avail;
  651.  
  652. }
  653.  
  654. non_suspect(start, beyond)
  655.     char *start;
  656.     char *beyond;
  657. {
  658.     int looking_good;
  659.     int len;
  660.     register char *cp;
  661.     register char *last;
  662.     char *skip_msg = "Warning: skipping legal but suspect line in hqx file";
  663.  
  664.     /* ensure it's long enough */
  665.     len = beyond - start;
  666.     looking_good = len >= suspect_shorter;
  667.     DEBUG && fprintf(debug, "DEBUG: non_suspect: long enough: %d\n",
  668.         looking_good);
  669.     DEBUG && fflush(debug);
  670.     if (!looking_good) {
  671.         fprintf(verbose, "%s -- line too short (%d < %d)\n",
  672.             skip_msg, len, suspect_shorter);
  673.         fflush(verbose);
  674.     }
  675.  
  676.     /* ensure it's different enough */
  677.     if (suspect_same && looking_good) {
  678.         last = beyond - 1;
  679.         for (cp = start; cp < last; cp++)
  680.             if (*cp != *last) {
  681.                 break;
  682.             }
  683.         /* is different */
  684.         looking_good = cp != last;
  685.         DEBUG && fprintf(debug,
  686.             "DEBUG: non_suspect: different enough: %d\n",
  687.             looking_good);
  688.         DEBUG && fflush(debug);
  689.         if (!looking_good) {
  690.             if (*last IS_LEGAL) {
  691.                 fprintf(verbose, "%s -- all one input char ('%c')\n",
  692.                     skip_msg, tr86[*last] );
  693.             } else {
  694.                 fprintf(verbose, "%s -- all chars mapped to 0x%02x\n",
  695.                     skip_msg, *last );
  696.             }
  697.             fflush(verbose);
  698.         }
  699.     }
  700.  
  701.     hqxsuspect = !looking_good;
  702.  
  703.     return looking_good;
  704. }
  705.  
  706. new_in_hqx_file()
  707. {
  708.     extern char **hqxnames_left;
  709.     int result;
  710.     long len;
  711.  
  712.     DEBUG && fprintf(debug, "entering new_in_hqx_file ...\n");
  713.     DEBUG && fflush(debug);
  714.  
  715.     if (*hqxnames_left[0] == '\0' || *hqxnames_left[0] == '-') {
  716.         result = FALSE;
  717.         goto exit;
  718.     }
  719.  
  720.     len = strlen(*hqxnames_left);
  721.     if (len >= sizeof(hqxfname))
  722.         error("Error: specified hqxfname is too long", "");
  723.     strcpy(hqxfname, *hqxnames_left++);
  724.     /*
  725.      * we used to use freopen,
  726.      * but now suffer the slight inefficiency of close/open
  727.      * to provide info_only and consistent handling
  728.      * with good software engineering methods
  729.      */
  730.     mclose(&hqxfile, "hqxfile");
  731.     hqxfile = mopen(hqxfname, ".hqx", "r");
  732.     hqxsuspect = 1;
  733.     (void)fgets(LINE_START, MAXLINE, hqxfile);
  734.     result = TRUE;
  735.  
  736. exit:
  737.     if (result == TRUE)
  738.         DEBUG && fprintf(debug, "... opened %s\n", hqxfname);
  739.     else
  740.         DEBUG && fprintf(debug, "... nothing to open\n");
  741.     DEBUG && fflush(debug);
  742.  
  743.     return result;
  744. }
  745.  
  746. /*
  747.  *  This procedure transparently encodes and writes the hqx output.  
  748.  *  It does run length and 8 to 6 encoding.
  749.  */
  750. empty_hqxbuf()
  751. {
  752.     register ulong c, accum, last_c;
  753.     register byte *fast_buf, *fast_line;
  754.     register int state86, dont_look_for_runs = FALSE, run_length;
  755.     extern int maxlines;
  756.  
  757.     run_length = save_run_length;
  758.     last_c = buf_start[-1];
  759.     fast_buf = buf_start;
  760.     fast_line = line_ptr;
  761.     state86 = save_state;
  762.     accum = save_accum;
  763.     while (fast_buf < buf_ptr) {
  764.         c = *fast_buf++;
  765.         if (dont_look_for_runs)
  766.             dont_look_for_runs = FALSE;
  767.         else if (last_c == c && run_length < MAXRUN) {
  768.             run_length++;
  769.             continue;
  770.         } else {
  771.             if (run_length > 1) {
  772.                 --fast_buf;
  773.                 if (run_length == 2 && last_c != RUNCHAR)
  774.                     c = last_c;
  775.                 else {
  776.                     c = RUNCHAR;
  777.                     *--fast_buf = run_length;
  778.                     dont_look_for_runs = TRUE;
  779.                 }
  780.                 run_length = 1;
  781.             } else
  782.                 last_c = c;
  783.             if (c == RUNCHAR && !dont_look_for_runs) {
  784.                 *--fast_buf = 0;
  785.                 dont_look_for_runs = TRUE;
  786.             }
  787.         }
  788.  
  789.         if (fast_line == line_end) {
  790.             if (line_count++ == maxlines)
  791.                 new_out_hqx_file();
  792.             fputs(LINE_START, hqxfile);
  793.             fast_line = line_start;
  794.         }
  795.         switch (state86++) {
  796.         case 0:
  797.             *fast_line++ = tr86[c >> 2];
  798.             accum = (c << 4) & 0x3f;
  799.             break;
  800.         case 1:
  801.             *fast_line++ = tr86[(c >> 4) | accum];
  802.             accum = (c << 2) & 0x3f;
  803.             break;
  804.         case 2:
  805.             *fast_line++ = tr86[(c >> 6) | accum];
  806.             if (fast_line == line_end) {
  807.                 if (line_count++ == maxlines)
  808.                     new_out_hqx_file();
  809.                 fputs(LINE_START, hqxfile);
  810.                 fast_line = line_start;
  811.             }
  812.             *fast_line++ = tr86[c & 0x3f];
  813.             state86 = 0;
  814.             break;
  815.         }
  816.     }
  817.     save_run_length = run_length;
  818.     buf_start[-1] = last_c;
  819.     buf_ptr = buf_start;
  820.     line_ptr = fast_line;
  821.     save_state = state86;
  822.     save_accum = accum;
  823. }
  824.  
  825. new_out_hqx_file()
  826. {
  827.     char filename[SYSNAMELEN + 7];
  828.     extern int maxlines;
  829.  
  830.     fprintf(hqxfile, "<<< End of Part %2d >>>\n", file_count);
  831.     mclose(&hqxfile, "hqxfile");
  832.     file_count++;
  833.     if (maxlines)
  834.         sprintf(filename, "%s%02d.hqx", hqxfname, file_count);
  835.     else
  836.         sprintf(filename, "%s.hqx", hqxfname);
  837.     hqxfile = mopen(filename, "", "w");
  838.     if (file_count > 1)
  839.         fprintf(hqxfile, "<<< Start of Part %2d >>>\n", file_count);
  840.     else
  841.         fprintf(hqxfile, "(This file must be converted with BinHex 4.0)\n\n");
  842.     line_count = 3;
  843. }
  844.  
  845. check_hqx_crc(calc_crc, msg, name)
  846.     word calc_crc;
  847.     char msg[], name[];
  848.  
  849. {
  850.     word read_crc;
  851.  
  852.     if (buf_ptr >= buf_end)
  853.         (void)fill_hqxbuf(0);
  854.     read_crc = *buf_ptr++ << 8;
  855.     if (buf_ptr >= buf_end)
  856.         (void)fill_hqxbuf(0);
  857.     read_crc |= *buf_ptr++;
  858.     if (read_crc != calc_crc)
  859.         error(msg, name);
  860. }
  861.  
  862. write_hqx_crc(calc_crc)
  863.     word calc_crc;
  864. {
  865.     if (buf_ptr == buf_end)
  866.         empty_hqxbuf();
  867.     *buf_ptr++ = calc_crc >> 8;
  868.     if (buf_ptr == buf_end)
  869.         empty_hqxbuf();
  870.     *buf_ptr++ = calc_crc;
  871. }
  872.  
  873. un_hqx(unpit_flag)
  874.     int unpit_flag;
  875. {
  876.     char type[5];    /* stuff EOS */
  877.     ulong hqx_datalen, hqx_rsrclen;
  878.     word un_pit();
  879.     int unpitting, bytes_read;
  880.     word calc_crc;
  881.     extern char **hqxnames_left;
  882.     int same_file_only = 0;
  883.     int active;
  884.  
  885.     /* we read EOF on this to transision, so the stream must be valid */
  886.     hqxfile = devnull;
  887.     line_end = line_start + HQXLINELEN;
  888.     buf_end = buf_start + HQXBUFLEN;
  889.  
  890.     while (1) {
  891.         total_bytes = 0;
  892.         line_ptr = line_start;
  893.         /* ensure that the line buffer is considered empty */
  894.         /* why we use SKIP and not newline, I'm not sure */
  895.         line_ptr[0] = SKIP;
  896.         save_state = 0;
  897.         save_run_length = 0;
  898.  
  899.         active = hqx_to_bin_hdr(type, &hqx_datalen, &hqx_rsrclen, same_file_only);
  900.         if (active == 0)
  901.             break;
  902.         same_file_only = 1;
  903.         type[4] = 0; /* set EOS */
  904.  
  905.         unpitting = unpit_flag && !strcmp(type, "PIT ");
  906.         DEBUG && fprintf(debug,
  907.             "DEBUG: unpit_flag=%d type=%s unpitting=%d\n",
  908.             unpit_flag, type, unpitting);
  909.         DEBUG && fflush(debug);
  910.         if (unpitting) {
  911.             mclose(&binfile, "binfile");
  912.             /* Do not unlink files we did not open */
  913.            if (!info_only)
  914.                 unlink(binfname);
  915.             bytes_read = total_bytes - (buf_end - buf_ptr);
  916.             calc_crc = un_pit();
  917.             bytes_read = total_bytes - (buf_end - buf_ptr) - bytes_read;
  918.             if (bytes_read != hqx_datalen) {
  919.                 fprintf(verbose,
  920.                     "Warning - Extraneous characters ignored in %s\n", binfname);
  921.                 fflush(verbose);
  922.             }
  923.         } else {
  924.             calc_crc = hqx_to_bin_fork(hqx_datalen);
  925.         }
  926.         check_hqx_crc(calc_crc, "File data CRC mismatch in %s", binfname);
  927.  
  928.         calc_crc = hqx_to_bin_fork(hqx_rsrclen);
  929.         check_hqx_crc(calc_crc, "File rsrc CRC mismatch in %s", binfname);
  930.  
  931.         if (!unpitting) {
  932.             mclose(&binfile, "binfile");
  933.         }
  934.  
  935.     }
  936.     mclose(&hqxfile, "hqxfile");
  937. }
  938.  
  939. re_hqx()
  940. {
  941.     word calc_crc;
  942.     ulong hqx_datalen, hqx_rsrclen;
  943.     extern char **hqxnames_left;
  944.     extern int maxlines;
  945.  
  946.     line_end = line_start + HQXLINELEN;
  947.     buf_end = buf_start + HQXBUFLEN;
  948.     while (*hqxnames_left[0] != '-') {
  949.         /* we write the trailer, so the stream must be valid */
  950.         hqxfile = devnull;
  951.  
  952.         /*
  953.        * We use the trick of setting our line_count at the limit to
  954.        * force an immediate transition on overflow.
  955.          */
  956.         line_count = maxlines;
  957.  
  958.         file_count = 0;
  959.         line_ptr = line_start;
  960.         *line_ptr++ = ':';
  961.         strcpy((char*)line_end, "\n");
  962.         buf_ptr = buf_start;
  963.         save_state = 0;
  964.         save_run_length = 1;
  965.  
  966.         bin_to_hqx_hdr(&hqx_datalen, &hqx_rsrclen);    /* calculates hqxfname */
  967.  
  968.         /*
  969.        * Now that we have hqxfname, start the new file if
  970.          * not yet started.  We no longer wait until the output
  971.          * buffer overflows, since empty files with short names didn't overflow!
  972.          */
  973.  
  974.         if (file_count == 0)
  975.             new_out_hqx_file();
  976.  
  977.         calc_crc = bin_to_hqx_fork(hqx_datalen);
  978.         write_hqx_crc(calc_crc);
  979.  
  980.         calc_crc = bin_to_hqx_fork(hqx_rsrclen);
  981.         write_hqx_crc(calc_crc);
  982.         /*
  983.        * To end a run and to get the last stray bits,
  984.          * temporarily add a char.
  985.          */
  986.         *buf_ptr = !buf_ptr[-1];
  987.         buf_ptr++;
  988.         empty_hqxbuf();
  989.         /* now toss any extra output character generated */
  990.         if (save_state != 2)
  991.             --line_ptr;
  992.  
  993.         /* if we're at the end of the line now, write it out */
  994.         if (line_ptr == line_end) {
  995.             fputs(LINE_START, hqxfile);
  996.             line_ptr = line_start;
  997.         }
  998.  
  999.         /* paste the trailing colon onto the end of the line */
  1000.         /* recall that line_ptr points into the line, not at the line */
  1001.         strcpy((char*)line_ptr, ":\n");
  1002.         
  1003.         /* and flush the output buffer */
  1004.         fputs(LINE_START, hqxfile);
  1005.  
  1006.         mclose(&hqxfile, "hqxfile");
  1007.         mclose(&binfile, "binfile");
  1008.  
  1009.     }
  1010. }
  1011.  
  1012.